System and method for rapid development of software applications

ABSTRACT

The present invention is a system and method for rapid development of software applications comprising: a field composer; a design composer; and a design repository; wherein the field composer is used to create field trees; wherein the design composer is used to create designs; wherein a design is a partial or complete configuration of a software application; wherein one or more data models is/are derived from one or more existing databases; and wherein the design repository stores designs, field trees, and data models.

CROSS-REFERENCE TO RELATED APPLICATION

This application claims priority back to U.S. Patent Application No.60/940,342 filed on 25 May 2007. The contents of that application arehereby incorporated by reference into the present disclosure.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates generally to the field ofcomputer-implemented inventions, and more specifically, to a system andmethod for rapid development of software applications.

2. Description of the Related Art

Virtually every large company in the world uses an automated businesssystem in some part of their business. These systems vary, but almostall of them have the requirement to display information and accept inputfrom end users. Examples of automated business systems run the gamutfrom online retail sites to delivery truck routing systems to insuranceindustry customer interfaces. Because building automated businesssystems is a complex and technically challenging process, business userswith average computer skills cannot create, modify, or maintain themwithout employing the expertise of software engineers or programmers.Furthermore, most automated business systems require interactions withsub-components, such as a database, which furthers the need for theinterface to be controlled by a software engineer.

These constraints make automated business system builds a lengthy andprohibitively expensive process. Business users need an easy andefficient way to build custom automated business systems that includevisual design elements of display pages (front-end interfaces) connectedto a database (interface to the back end). The automated business systemneeds to be built through a user-friendly interface that does notrequire technical knowledge.

Additionally, the software development industry has gone through aseries of changes to address the shortcomings of developing automatedbusiness systems. In the past, automated business systems weremainframe-based with primitive visual interfaces called green screens.Developers of these systems had limited choices for constructing usableand intuitive front-end interfaces. With the growth of the Internet,these options expanded rapidly. HTML, Java, and other programmingenvironments provided new, visually oriented methods for development andpowerful ways to create a new generation of automated business systems;however, they brought about a new set of challenges.

Back in the mainframe age, component connections were simple to managebecause components were tied together by one central system. Today,through the Internet, systems are accessible from anywhere on thenetwork, and there now exists the ability to connect differentcomponents from multiple data and service providers into oneinterdependent system. While the new capabilities of the Internet haveadded flexibility in the creation of user-friendly, front-end visualinterfaces, this flexibility increases the importance of standards andinterfaces between systems. Consequently, software engineers continue tobe a necessity for the creation of visual widgets and for tying thesewidgets to the back-end interfaces. The need for software engineers tobe involved in every step of development puts limits on the “advances”these technologies have made.

Furthermore, the use of automated business systems has becomeincreasingly critical to the success of businesses that use them.Millions of dollars are at stake when these systems shut down;therefore, failure is not acceptable, and uptime and availabilityperformance are paramount. The environment in which these automatedbusiness systems need to perform in today's world must also be takeninto consideration. With fraud loss on the increase, environmentsecurity has become vitally important. Compliance with governmentregulation designed to protect consumers has also become a requirementof any automated business system.

There are no automated business systems on the market that successfullyaddress all of these issues. An automated business system in today'sworld must retain the benefits of the Internet, and still provide auser-friendly interface that allows non-technical business users toquickly build, modify, and maintain automated business systems withfront-end visual interfaces that are connected to a database thatprocesses and stores high-volume, mission-critical data. The system mustalso address uptime and availability requirements, as well as securityand compliance issues.

BRIEF SUMMARY OF THE INVENTION

The present invention is a system for rapid development of softwareapplications comprising: a field composer; a design composer; and adesign repository; wherein the field composer is used to create fieldtrees; wherein the design composer is used to create designs; wherein adesign is a partial or complete configuration of a software application;wherein one or more data models is/are derived from one or more existingdatabases; and wherein the design repository stores designs, fieldtrees, and data models.

In a preferred embodiment, a design comprises programmer-created pages,programmer-created frames, tool-created pages, and/or tool-createdframes. Preferably, the system further comprises a central server and aclient, wherein the central server connects to the design repository andretrieves designs, field trees and data model(s); wherein the clientdisplays in a runtime environment the software application that iscreated in the design composer; and wherein an end user enters, editsand/or reviews data through the client using the software applicationthat is created in the design composer.

In a preferred embodiment, the central server uses the data model(s) toconnect to one or more customer databases; wherein the database fromwhich each data model is derived has a schema; wherein each customerdatabase has a schema; and wherein the schema of the database from whicheach data model is derived matches the schema of at least one customerdatabase. Preferably, the customer database is used by the softwareapplication to store and retrieve data entered by the end user throughthe client.

In a preferred embodiment, the system further comprises a persistencelayer, wherein each customer database has a native database queryformat; and wherein the persistence layer translates the data entered bythe end user to the native database query format of the customerdatabase. Preferably, more than one data model is used per softwareapplication created in the design composer. The data models arepreferably derived from different types of databases.

In a preferred embodiment, there is a one-to-one relationship betweenthe number of data models used per software application created in thedesign composer and the number of customer databases. Preferably, a datamodeling standard is used to automatically infer the structure of thedatabase schema of the database from which the data model is to bederived. After the data modeling standard is used to automatically inferthe structure of the database schema of the database from which the datamodel is to be derived, the data model is preferably derived using areverse engineering tool.

In a preferred embodiment, the field composer comprises a data modelview and a field view; wherein each data model comprises fields; whereinthe data model view is automatically populated with the fields from thedata model(s); and wherein to create a field tree in the field composer,a business user drags and drops data elements from the data model viewto the field view of the field composer. Preferably, the design composercomprises a field tree window, and the field tree created in the fieldcomposer is displayed in the field tree window of the design composer.

In a preferred embodiment, a field tree may be built from more than onedata model, and each data model is represented by a root in the fieldtree. Preferably, the field tree created in the field composer anddisplayed in the field tree window of the design composer maps the dataelements to one or more customer databases.

In one embodiment, the system further comprises a persistence layer,wherein the persistence layer is an application programming interfacethat communicates with an object model persistence applicationprogramming interface. In an alternate embodiment, the persistence layeris an application programming interface that communicates directly withone or more data models.

In a preferred embodiment, the persistence layer is used within thefield composer to create a hierarchical view of a relational data model.The field composer preferably comprises a data model view, and thehierarchical view of the data model is displayed in the data model viewof the field composer.

In a preferred embodiment, each data model comprises fields, and thefield composer allows business users to select data model(s) andspecific fields from a data model for use on specific pages of thesoftware application. Preferably, the field composer comprises a datamodel view and a field view, wherein all available fields within aselected data model appear in the data model view of the field composer,and wherein the selected fields appear in the field view. The selectedfields are preferably automatically saved and grouped according to thedata model from which they came.

In a preferred embodiment, a single field tree is created for eachsoftware application, and the design composer is used to build thesoftware application using the field tree that is created in the fieldcomposer. Preferably, the software application comprises one or morepages, wherein each page comprises a visual display, and wherein thedesign composer is used to configure the visual display of the pages inthe software application.

In a preferred embodiment, the design composer comprises a propertieswindow, a field tree window, a pages window, a palette window and acanvas. Optionally, the design composer further comprises a frameswindow.

In a preferred embodiment, the software application comprises one ormore pages, and the canvas is where business users design, build andmodify the pages of the software application. Preferably, the softwareapplication comprises one or more pages, the pages comprise designelements, and the properties window is used to format the designelements of the pages. In one embodiment, the software application has apage flow, and the page flow is defined in the properties window. Inanother embodiment, the software application has a page flow, and pageflow is controlled by events on buttons that have been dragged anddropped onto the canvas from the palette window.

In a preferred embodiment, the software application comprises one ormore pages, and the field tree window is where a business user selectsthe field(s) he wants to use on a page. Preferably, the softwareapplication comprises one or more pages, and the pages window is used toadd, delete, modify and rename pages. Preferably, the pages windowallows a business user to add programmer-created pages to the softwareapplication.

In a preferred embodiment, the software application comprises one ormore pages, and the palette window is used to add design elements to apage. Preferably, the design elements that are added from the palettewindow are arranged and sized on the canvas. Preferably, a user mayselect a button from the palette window, drag and drop the button ontothe canvas, and select an action from the properties window to apply tothe button.

In a preferred embodiment, the software application comprises one ormore pages, and the frames window is used to add one or more frames to apage. Preferably, each frame comprises one or more design elements, andwhen a design element in a frame is modified, the modificationpropagates to every place in a design in which the frame is used.

In a preferred embodiment, the software application comprises one ormore pages, and to build a page, a business user selects one or morefields from the field tree window of the design composer and places themonto the canvas. Preferably, the fields placed onto the canvas form alayout, and the layout displayed on the canvas is identical to thatwhich will appear to an end user in a runtime environment.

In a preferred embodiment, when a design is completed, the design issaved to the design repository. Preferably, modified designs are savedas new versions, and both new and prior versions are available for usein the design composer. Preferably, when a design is completed and readyto be run in a runtime environment, the design is deployed from thedesign repository to a central server.

In a preferred embodiment, the design repository is used to test thesoftware application before it is deployed to the runtime environment.Preferably, designs, fields trees and data models that are stored in thedesign repository are shared across multiple platforms and between endusers.

In a preferred embodiment, the software application is run in a runtimeenvironment, wherein the runtime environment provides for userpermissions, and wherein the user permissions include permissions foraccessing the application, permissions for accessing specific pages, andpermissions for accessing specific fields.

The present invention is also a method for rapid development of softwareapplications comprising: providing a field composer; providing a designcomposer; and providing a design repository; wherein the field composeris used to create field trees; wherein the design composer is used tocreate designs; wherein a design is a partial or complete configurationof a software application; wherein one or more field trees is/arederived from one or more existing data models; and wherein the designrepository stores designs, field trees, and data models.

In a preferred embodiment, a design comprises programmer-created pages,programmer-created frames, tool-created pages, and/or tool-createdframes. Preferably, the method further comprises providing a centralserver and a client, wherein the central server connects to the designrepository and retrieves designs, field trees and data model(s); whereinthe client displays in a runtime environment the software applicationthat is created in the design composer; and wherein an end user enters,edits and/or reviews data through the client using the softwareapplication that is created in the design composer.

In a preferred embodiment, the central server uses the data model(s) toconnect to one or more customer databases; wherein the database fromwhich each data model is derived has a schema; wherein each customerdatabase has a schema; and wherein the schema of the database from whicheach data model is derived matches the schema of at least one customerdatabase. Preferably, the customer database is used by the softwareapplication to store and retrieve data entered by the end user throughthe client.

In a preferred embodiment, the method further comprises providing apersistence layer, wherein each customer database has a native databasequery format; and wherein the persistence layer translates the dataentered by the end user to the native database query format of thecustomer database. Preferably, more than one data model is used persoftware application created in the design composer. The data models arepreferably derived from different types of databases.

In a preferred embodiment, there is a one-to-one relationship betweenthe number of data models used per software application created in thedesign composer and the number of customer databases. Preferably, a datamodeling standard is used to automatically infer the structure of thedatabase schema of the database from which the data model is to bederived. After the data modeling standard is used to automatically inferthe structure of the database schema of the database from which the datamodel is to be derived, the data model is preferably derived using areverse engineering tool.

In a preferred embodiment, the field composer comprises a data modelview and a field view; wherein each data model comprises fields; whereinthe data model view is automatically populated with the fields from thedata model(s); and wherein to create a field tree in the field composer,a business user drags and drops data elements from the data model viewto the field view of the field composer. Preferably, the design composercomprises a field tree window, and the field tree created in the fieldcomposer is displayed in the field tree window of the design composer.

In a preferred embodiment, a field tree may be built from more than onedata model, and each data model is represented by a root in the fieldtree. Preferably, the field tree created in the field composer anddisplayed in the field tree window of the design composer maps the dataelements to one or more customer databases.

In one embodiment, the method further comprises providing a persistencelayer, wherein the persistence layer is an application programminginterface that communicates with an object model persistence applicationprogramming interface. In an alternate embodiment, the persistence layeris an application programming interface that communicates directly withone or more data models.

In a preferred embodiment, the persistence layer is used within thefield composer to create a hierarchical view of a relational data model.The field composer preferably comprises a data model view, and thehierarchical view of the data model is displayed in the data model viewof the field composer.

In a preferred embodiment, each data model comprises fields, and thefield composer allows business users to select data model(s) andspecific field from a data model for use on specific pages of thesoftware application. Preferably, the field composer comprises a datamodel view and a field view, wherein all available fields within aselected data model appear in the data model view of the field composer,and wherein the selected fields appear in the field view. The selectedfields are preferably automatically saved and grouped according to thedata model from which they came.

In a preferred embodiment, a single field tree is created for eachsoftware application, and the design composer is used to build thesoftware application using the field tree that is created in the fieldcomposer. Preferably, the software application comprises one or morepages, wherein each page comprises a visual display, and wherein thedesign composer is used to configure the visual display of the pages inthe software application.

In a preferred embodiment, the design composer comprises a propertieswindow, a field tree window, a pages window, a palette window and acanvas. Optionally, the design composer further comprises a frameswindow.

In a preferred embodiment, the software application comprises one ormore pages, and the canvas is where business users design, build andmodify the pages of the software application. Preferably, the softwareapplication comprises one or more pages, the pages comprise designelements, and the properties window is used to format the designelements of the pages. In one embodiment, the software application has apage flow, and the page flow is defined in the properties window. Inanother embodiment, the software application has a page flow, and pageflow is controlled by events on buttons that have been dragged anddropped onto the canvas from the palette window.

In a preferred embodiment, the software application comprises one ormore pages, and the field tree window is where a business user selectsthe field(s) he wants to use on a page. Preferably, the softwareapplication comprises one or more pages, and the pages window is used toadd, delete, modify and rename pages. Preferably, the pages windowallows a business user to add programmer-created pages to the softwareapplication.

In a preferred embodiment, the software application comprises one ormore pages, and the palette window is used to add design elements to apage. Preferably, the design elements that are added from the palettewindow are arranged and sized on the canvas. Preferably, a user mayselect a button from the palette window, drag and drop the button ontothe canvas, and select an action from the properties window to apply tothe button.

In a preferred embodiment, the software application comprises one ormore pages, and the frames window is used to add one or more frames to apage. Preferably, each frame comprises one or more design elements, andwhen a design element in a frame is modified, the modificationpropagates to every place in a design in which the frame is used.

In a preferred embodiment, the software application comprises one ormore pages, and to build a page, a business user selects one or morefields from the field tree window of the design composer and places themonto the canvas. Preferably, the fields placed onto the canvas form alayout, and the layout displayed on the canvas is identical to thatwhich will appear to an end user in a runtime environment.

In a preferred embodiment, when a design is completed, the design issaved to the design repository. Preferably, modified designs are savedas new versions, and both new and prior versions are available for usein the design composer. Preferably, when a design is completed and readyto be run in a runtime environment, the design is deployed from thedesign repository to a central server.

In a preferred embodiment, the design repository is used to test thesoftware application before it is deployed to the runtime environment.Preferably, designs, fields trees and data models that are stored in thedesign repository are shared across multiple platforms and between endusers.

In a preferred embodiment, the software application is run in a runtimeenvironment, wherein the runtime environment provides for userpermissions, and wherein the user permissions include permissions foraccessing the application, permissions for accessing specific pages, andpermissions for accessing specific fields.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a diagram of the technical architecture of the presentinvention.

FIG. 2 is a diagram of the technical architecture of the presentinvention with the persistence layer shown.

FIG. 3 is an example of the database schema view displayed in the fieldcomposer of the present invention.

FIG. 4 is an illustration of a typical prior art database schema view.

FIG. 5 is a screen shot of the design composer of the present inventionwith the properties, field tree, pages, frames and palette windowsshown.

FIG. 6 is a screen shot of the design composer of the present inventionwith the properties, field tree, pages, frames and palette windowshidden.

REFERENCE NUMBERS

1 Design environment

2 Field composer

3 Design composer

4 Design repository

5 Data model

6 Database (from which data model is derived)

7 Customer database

8 Central server

9 Client

10 Runtime environment

11 Persistence layer

12 Field view (of field composer)

13 Data model view (of field composer)

14 Properties window (of design composer)

15 Field tree window (of design composer)

16 Pages window (of design composer)

17 Frames window (of design composer)

18 Palette window (of design composer)

20 Canvas

21 Tab style field type (of design composer)

22 Table style field type (of design composer)

23 Panel style field type (of design composer)

DETAILED DESCRIPTION OF INVENTION

1. Overview

The present invention is a system and method that allows for the rapiddevelopment of software applications, such as automated businesssystems. The invention is user-friendly and can be used by non-technicalbusiness users to build, modify, and maintain automated businesssystems, including front-end visual components that connect to adatabase for processing in the company's distributed network. Thepresent invention provides this capability with minimal intervention bysoftware engineers.

The present invention is comprised of three main components: the designenvironment, the design repository, and the runtime environment. Thesecomponents work together to create a software application wherein thefields, display format, and databases to which the application connectsare all determined by the business user.

The design environment comprises a field composer and a design composer.The field composer and design composer run locally as an application(without a browser). As a result of selections made by the business userin the field and design composers, the present invention automaticallygenerates all database interactions based on the fields that businessusers place on each page. It also allows business users to define thevisual aspects of an automated business system, including individualpage layout, page groupings, and page navigation.

The design repository stores artifacts, which within the context of thepresent invention means designs, field trees, and data models. As usedherein, the term “design” refers to a partial or complete configurationof an application created with the present invention. A design maycomprise: (i) programmer-created pages and frames that are created bythe company's software engineers; and/or (ii) tool-created pages andframes that are created by business users with the invention.Programmer-created pages allow the invention to provide for complexfunctions and pages that cannot be built without programmerintervention. Programmer-created pages must adhere to software frameworkspecifications that allow the programmer-created pages to interactcorrectly with the invention. Both programmer-created pages and framesand tool-created pages and frames offer a jump start on creatingautomated business systems by providing common functions that can beused and reused.

Business users who have permissions to the system have access to thedesign repository. The design repository acts as a library whereartifacts can be shared by multiple business users to facilitate quickerbuilds. The number of artifacts that can be stored in the designrepository is unlimited, and business users have the option of decidingwhich artifacts, if any, they want to use. Furthermore, designs can beversioned and saved for future use or reference.

The runtime environment is the real-time setting in which the softwareapplications designed through the use of the present invention work. Theruntime environment is preferably shared, distributed, scalable, andredundant. Preferably, it is also capable of processing high-volume,real-time transactions in a mission-critical environment that requiresthe highest level of security.

With these three main components—the design environment, the designrepository, and the runtime environment—the present invention combinesunprecedented ease of use with the ability to build, modify, maintain,and deploy automated business systems. These systems can be built bynon-technical business users with average computer skills, which makesthe entire process efficient and cost-effective.

FIG. 1 depicts the technical architecture of the system, including therelationships between the main components of the system and the users ofthe system. The users of the system include (i) the business user whocreates the system in the design environment 1 and (ii) the end user whoenters data into the system for processing in the runtime environment10. As shown in FIG. 1, the business user runs the invention (fieldcomposer and design composer 2, 3) on a local computer to create fieldtrees and designs. The field trees (there is one field tree per design)and designs are then stored in the design repository 4.

Data models 5 are derived from one or more existing databases 6 andstored in the design repository 4. One data model 5 is derived from asingle database 6. In the runtime environment 10, the end user runs theclient 9, which displays the design that was created in the designenvironment 1. The central server 8 connects to the design repository 4and retrieve artifacts necessary to run the application that was createdin the design environment 1. The central server 8 uses the data model(s)5 to connects to the customer database(s) 7. The central server could beone or more central servers.

The database 6 from which each data model 5 is derived has a schema, andthat schema must match the schema of the corresponding customer database7. Note that it is possible for the database 6 from which the data model5 is derived and the customer database 7 to be the same database,although it would be unlikely in most business scenarios. The presentinvention may utilize more than one data model 5 per application. Thecustomer database 7 is used by the automated business system to storeand retrieve data entered by the end user through the client 9.

2. Design Environment

A. Data Models

The present invention is designed to work with a database through a datamodel without the need for programmer intervention. As stated above, thedata model 5 is derived from an existing database 6. The presentinvention utilizes a data modeling standard to enable the system toautomatically infer the structure of the database schema of the database6 from which the data model is being derived. Once the structure of thedatabase schema is known, the data model 5 can be derived.

In a preferred embodiment, the data modeling standard includes variousnaming conventions that are applied to the database in order to identifystructures and data types within the database. The data modelingstandard also includes naming conventions for tables and columns of thedatabase in order to identify tables within the database and therelationships between them. For example, in one embodiment, the datamodeling standard includes certain criteria for type tables, collections(i.e., the many end of a one-to-many or many-to-many relationship), andBoolean types.

In a preferred embodiment, after the data modeling standard is applied,the data model 5 is reverse engineered from a database 6 using HibernateTools, a commercially available reverse engineering tool. This toolinspects an existing database and produces a data model that representsthe schema of the inspected database. The present invention is notlimited to the use of Hibernate Tools, however, and the data model couldbe generated using any other method that accomplishes that same result.

Once created, the data model 5 can be updated with new tables and/orfields as the database 6 changes. A database administrator updates thedatabase schema from which the data model 5 was derived (that is, thedatabase schema for database 6), after which the data model is recreatedto include the changes to the database schema. The business user thenhas the option of promoting the new table and/or field from the datamodel view (see reference number 13 in FIG. 3) to the field view (seereference number 12 in FIG. 3) in the field composer 2. The businessuser would then need to open up the design composer 3 and load the newfield tree in order for the changes to be available for design.

The present invention is not limited to the use of a specific datamodel. Business users can select different data models to createdifferent types of software applications, or they may use different datamodels within the same software application. For example, a businessuser may select a home loan data model (i.e., a data model derived fromthe database schema of a home loan database) and a credit card datamodel (i.e., a data model derived from the database schema of a creditcard database) to build a loan origination system.

Each application is connected to a database 7 with the same databaseschema from which the data model was derived (database 6), and if morethan one data model is used, then the application connects to onedatabase 7 for each data model 5 used. In other words, there is aone-to-one relationship between the number of data models 5 used withinthe context of a single application and the number of databases 7 usedby the customer when the application is deployed. Further, data models 5can be derived from different types of databases, including databasesthat utilize non-traditional storage methods.

B. Persistence Layer

The present invention uses a persistence layer 11 to communicate withthe database 7. FIG. 2 is a diagram of the technical architecture of thepresent invention with the persistence layer 11 shown.

In a preferred embodiment, the persistence layer 11 is an applicationprogramming interface (API) that communicates with the Hibernate API,which in turn communicates with one or more data models 5. In lieu ofthe Hibernate API, any object model persistence API could be used. In analternate embodiment, the persistence layer 11 is an API thatcommunicates directly with one or more data models 5.

The persistence layer 11 acts as a translator between the database 7 andthe business user's automated business system that has been generated bythe invention. Specifically, the persistence layer 11 is utilized in thefield composer 2 of the present invention, and also to allow the centralserver 8 to communicate with the database 7.

The persistence layer 11 is used within the field composer 2 to create arelational view of the data model 5. Referring to FIG. 3, the fieldcomposer 2 presents a relational data model (in the data model view 13),and the business user drags and drops desired data elements (databasestructures) onto a field tree 12 to create a hierarchical visualrepresentation of the data model for use in the design composer 3 (seeFIG. 5). The field tree 12 maps the data elements to the database 7,which typically means that each data element in the field treecorresponds to a table or column in the customer database 7. The fieldtree 12 also displays in the design composer 3 in the form of ahierarchical data model for use in designing and building pages.

The persistence layer 11 is also used by the central server 8 after datahas been entered into the automated business system by end users(through the client 9) in the runtime environment 10. Specifically, thepersistence layer 11 translates data entered by the end user back to thedatabase 7. The purpose of the invention is to build pages for anautomated business system that collects, stores, and displays data froma database. This system connects with a database 7 that matches the datamodel 5 selected by the business user in the field composer 2.

The end user accesses the automated business system in the runtimeenvironment 10 to enter, edit and review existing data. When the enduser is finished, the data is transmitted to the central server 8, whichstores the information back to the database 7 via the persistence layer11. The persistence layer 11 translates the entered data to the nativedatabase query format of the database 7. This process allows theautomated business systems created with the invention to bedatabase-independent. In a preferred embodiment, Java DatabaseConnectivity (JDBC) is used to connect the runtime environment 10 to thedatabase 7.

C. Field Composer

The field composer 2 of the present invention is a tool from which ahierarchical view of a relational data model is created for subsequentuse in the design composer 3. Referring to FIG. 3, the field composer 2(through the persistence layer) interrogates the relational data modelstructure that is contained in the data model 5 and displays thatstructure in the data model view 13 of the field composer 2. In order toaccomplish this, the field composer 2 connects to a database using adata model that corresponds to the database and analyzes the entityclasses within the object model of the database along with the databasemetadata available from the database itself to derive the entities andfields to present in the data model view 13.

The invention uses the persistence layer 11 to convert the complexdatabase structure of the relational data model (see FIG. 4) to anobject model that is easy for non-technical business users tounderstand. The field composer 2 allows business users to choose thedata model they wish to use (from the File menu) and to select thespecific fields they wish to use on their pages.

In a preferred embodiment, all available fields within the selected datamodel will appear in the data model view 13 of the field composer 2. Thedata model view 13 displays the fields available for use within theselected data model. Business users drag fields from the data model view13 and drop them onto the field view 12, thereby creating a field tree.

As each field is selected, the business user can name it. The presentinvention also allows for renaming of pre-existing fields within theview of the data model. To change the original name of a field, thebusiness user highlights the field name and selects Rename from the Editmenu. The business user is then prompted to type in the new name.Although the new name is displayed in the field composer for use inbuilding new pages, the new name does not change the actual name withinthe data model.

After the user selects the desired fields from the data model with thefield composer, the selected fields are saved and grouped according tothe data model from which they came. These fields are then used when thebusiness user goes on to build subsequent pages in the design composer3.

FIG. 3 is an example of the database schema view displayed as a datamodel in the field composer of the present invention. This figureillustrates how the invention simplifies the database view shown in FIG.4 and displays it in the field composer in a way that makes it easy fornon-technical business users to understand. As shown in FIG. 3, thefield composer comprises a field view 12 and a data model view 13. Thedata model view 13 shows the full list of fields available for thebusiness user to select within the field composer 2. The field view 12shows the list of fields after they have been selected by the businessuser in the field composer.

In a preferred embodiment, a field tree may be built from more than onedata model 5. Each new data model 5 is represented by a new root in thefield tree 12. In turn, each data model 5 is derived from a databaseschema. If multiple data models 5 are used to build a field tree 12,then the present invention will use multiple databases. The number ofdata models in the field tree will correspond to the number of databasesutilized in the present invention. The database schema from which thedata model was derived must correspond to the database schema for thedatabase 7 that is used by the present invention in the runtimeenvironment.

D. Design Composer

i. Creation of Pages and Frames

The design composer 3 is a tool for building the automated businesssystem using the field tree 21 that was created in the field composer 2.Specifically, the design composer 3 allows business users to configurethe visual display of their automated business system pages. FIG. 5 is ascreenshot of the design composer 3 and shows the properties 14, fieldtree 15, pages 16, frames 17, and palette 18 windows. The canvas 20 isthe area within the design composer where business users design, buildand modify the pages of their automated business systems.

The properties window 14 allows business users to format design elementsof their page, such as fonts, fields and colors. All formatting of anydesign element used in the canvas 20 is done through the propertieswindow 14. The field tree window 15 allows business users to choose thefields they want to use on their page. The pages window 16 allowsbusiness users to add, delete, modify and rename pages of theirautomated business system. It also displays a list of the pages used inthe automated business system and provides the ability for businessusers to add programmer-created pages to their automated businesssystem. The frames window 17 allows users to select frames as part ofthe page they are building. The palette window 18 allows business usersto add design elements—logos, labels, images, rules, buttons, etc.—totheir page. These design elements may then be formatted in theproperties window 14. FIG. 5 shows a sample of fields being laid out inthe canvas 20 using a tab style field format.

In a preferred embodiment, the fields from the field tree 12 of thefield composer 2 display in the field tree window 15 of the designcomposer 3. Referring to FIG. 5, to build a page, fields are selectedfrom the field tree window 15 and placed onto the canvas 20. Fields areformatted in the properties window 14 and can be positioned anywhere onthe canvas 20. In a preferred embodiment, the invention is a “WYSIWYG”(meaning “What You See Is What You Get”). As the page is created, thelayout displayed on the canvas 20 is identical to that which will appearto end users in the runtime environment 10. FIG. 6 illustrates a varietyof field type styles, including tab style 21, table style 22, and panelstyle 23.

The properties window 14 allows business users to modify fieldcharacteristics. It shows all the characteristics or “properties”associated with the selected fields, including, but not limited to,field or label font size, style or color, background color, andalignment. To change a specific characteristic of a field, businessusers highlight the field and modify it in the properties window 14. Theproperties window 14 is also where business users define the page flowof the automated business system by selecting the next page to displayin the system. Page flow can also be controlled by events on buttonsthat have been dragged and dropped onto the canvas 20 from the palettewindow 18.

As shown in FIG. 5, a palette window 18 is also available for use withinthe design composer 3. The palette window 18 contains design elementssuch as images, vertical and horizontal rules, boxes, and labels thatbusiness users can add to the page. Design elements can bedragged-and-dropped onto the canvas 20 and arranged and sized on thecanvas 20 as needed.

A second option for page creation also exists within the presentinvention in the form of programmer-created pages. Rather than selectingfields with the field composer, business users can open existing pagetemplates from the design composer. These programmer-created pages canbe modified to fit specific business needs. To modify aprogrammer-created page, the business user can change page propertiesand page flow just as he or she would with tool-created pages.

In addition to allowing business users to create pages, the designcomposer also provides the ability to create frames that can be reusedacross multiple pages. A frame is a template that can be embedded on apage and that may contain text, graphics, buttons, and any other designelements that may appear on a page. For example, a business user maywish to display a set of design elements on multiple pages of hisautomated business system. To create a frame, the business user selects“Add” from the frame window 17 and build the frame in the same manner inwhich he or she would build a page. The frame can then be reusedthroughout the design. When design elements are modified within theframe, the changes propagate to every place in which the frame is usedin the design. In a preferred embodiment, predefined frames areavailable in the frame window 17 in the same way that predefined pagesare available in the pages window 16. Programmer-created frames can beselected and utilized from the design composer.

Once the design is built in the design composer, the business user savesit to the design repository 4. When the designs are completed and readyto be run in the runtime environment 10, they are deployed from thedesign repository 4 to the central server 8. A design can be laterreopened and edited, and modified designs are saved as new versions. Ina preferred embodiment, the invention allows the business user to revertto a prior version of a design if necessary.

ii. Event-Action Methodology

In a preferred embodiment, pages built with the design composer use anevent-action methodology whereby any number of intended actions can beassociated with events that are triggered by the end user. Event-actionmethodology associates a specific event, such as a keystroke or mouseclick, with a specific action. For example, when an end user initiatesan event, such as clicking the “Save” button, the application mayperform one or more actions, such as saving data, checking data foraccuracy, and advancing the display page.

The following are examples of event-action methodology:

(1) Button Click—the event occurs when the end user clicks a specificbutton. Different actions may be associated with this event, such asadvancing to the next display page, saving data, or closing a softwareapplication,

(2) Page Flow—the event and subsequent action occur when entering onedisplay page and leaving another. For example, within a Web browser,clicking the “Next” button sends the end user to the next page withinthe website. Clicking the button is the event, and entering the new pageis the action. There may also be other actions associated with thisevent. For example, data may be saved before entering the new displaypage.

(3) Field Exit—the event occurs when the end user directs the cursor toleave the specific field. The action associated with this event might beto check the validation of data entered into the field.

iii. Field Validation

The design composer also provides the ability to define validation logicfor each screen field (through the properties window 14). Validationlogic allows business users to define the format and length or range ofthe information that can be entered into a field. For example, SocialSecurity Number may need to be validated to ensure that it contains ninecharacters that are all numeric. More complex validations can beconducted, such as checking to see if the first three characters arezero, which would indicate that the number is invalid.

Validation rules are enforced at runtime. When the system determinesthat input is invalid, the system can display an error message orinstructions on how to fill in the field correctly in the form of popupmessages shown when the mouse pointer hovers over the field. Morecomplex actions can be defined based on the validation of the fieldinput (again through the properties window 8), such as making fieldsconditionally required based on the input of other fields.

The designer selects pass, warn or fail behavior for fields that fail tovalidate at runtime. Upon leaving the page or initiating the saveaction, if the page contains any invalid field with the fail behaviorspecified, the user is notified, and the action is prevented. Otherwise,if any invalid field has the warm behavior specified, the user is askedwhether or not to perform the action.

iv. Event Sources

An event source is an interface element, such as a button, with which acomputer user initiates an action. The event source triggers an actionto be performed by the system in the runtime environment. In the designcomposer, business users can select various event sources to use ontheir pages. For example, they may select a “Continue” button to displayat the bottom of each page. After dragging and dropping the “Continue”button onto the design composer from the palette window 18, the businessuser selects a corresponding action from the properties window 14 toapply to the button (widget) that links the button to a specific action.The “Continue” button may initiate different actions, depending on theaction associated with it. For example, a business user may decide tolink the “Continue” button to the action of advancing to the next page.The range of actions that can be assigned to an event source is wide.Other examples include calls to decisioning or workflow engines andcalls to external data sources.

3. Design Repository

A. Design Storage and Library

Design takes place in the design environment 1. In this phase, businessusers are in the process of configuring the pages of their design tocreate the desired layout and flow of their automated business system.The design repository 4 stores the artifacts that will eventually beused to create the automated business system that will be utilized byend users in the runtime environment 10. It is also used as a testingenvironment in which a business user can test his automated businesssystem before it is deployed to the runtime environment 10.

The design repository 4 also acts as a central library where artifactscan be stored and shared across multiple platforms and between other endusers if permissions allow. Permissions to access the central librariesare defined by the business users in the individual libraries, which areaccessed through the administrative sections of the design composer.Complete predefined software applications can also be designed andshared, or sold as templates for standard automated business systems.

B. Deployment Tool

The deployment tool is used to manage deployment of designs to theruntime environment. This tool interacts with the design repository 4and runtime environment 10 to deploy instances of the server softwareitself along with a design and its associated artifacts, such as datamodel(s) 5 and programmer-created pages and frames. The deployment toolalso can be used to start and stop and monitor the central server.

The design repository 4 uses the deployment tool to provide the businessuser with the ability to quickly deploy and exercise a single design,and, when the user is finished, shut down and discard the serversoftware.

4. Runtime Environment

End users work in the runtime environment 10, where all of thecomponents of the invention are integrated to create a completeautomated business system. The end user accesses the pages of thespecific automated business system to enter, edit, or review data thatis transmitted back to the system for storage to the database. Displaypages and data fields cannot be created or modified in the runtimeenvironment; data can only be entered. The runtime environment can alsobe used to perform integration testing of all the components of thecomplete automated business system to verify that it is performing asexpected.

A. Central Server

After retrieving the artifacts (such as pages) from the designenvironment 1, the deployment tool loads them onto the central server 8.End users access specific automated business systems by connecting tothe central server 8 in a variety of ways. In a preferred embodiment,access occurs via secure Internet connection, such as an HTTP over SSL(HTTPS).

The central server 8 provides a similar function as the designrepository 4, the difference being that the design repository 4 is adevelopment holding place (and design library and testing environment)for the designs, while the central server 8 is where the completedautomated business system is executed.

In a preferred embodiment, the central server 8 also receives dataentered by end users into the automated business system in the runtimeenvironment 10. The central server 8 receives data and passes it throughthe persistence layer 11, where the data is translated to the nativedatabase query format of the database 7. Once translated, data is storedin the database 7 that corresponds to the data model 5 that wasinitially selected by the business user in the field composer 2.

B. Security

In a preferred embodiment, the runtime environment 10 providesauthentication and authorization for the automated business systems thatare built with the present invention. The runtime environment 10 ispreferably engineered to process transactions for automated businesssystems that operate in the most security intensive industries in theworld. In today's environment, all data that is entered into the systemand transmitted over any network must be encrypted so that personal datais not exposed and the credentials used to perform each transaction areauthenticated. Even data inside the central server in transit to thedatabase or other services may need to be encrypted. In the preferredembodiment, therefore, all traffic between the business user and thecentral server is preferably 128-bit encrypted over an SSL Internetconnection and 128-bit encrypted over the internal network between thecentral server and the database.

In a preferred embodiment, the runtime environment 10 also provides forauthorized user access to pages, frames and/or fields. Three basiclevels of access include: modifiable, where the user can view and/ormodify the pages, frames and or fields; viewable, where the user canview but not modify the pages, frames and/or fields; and none, where theuser cannot view or modify the pages, frames and/or fields.

Design elements are assigned security categories at design time in thedesign composer 3. Authorization is managed at runtime using thesecurity management features in the client 9, where authorizable objectssuch as groups of users are assigned levels of access to the securitycategories within the design.

The permission schema is flexible and allows business users to set upsecurity for all types of automated business systems, includinghigh-traffic systems with hundreds of pages, as well as low-trafficsystems with only one or two pages.

User creation, deletion, and configuration of password parameters, suchas password strength and aging, are accomplished at runtime using thesecurity management features in the client 9.

C. Server Distribution

In a preferred embodiment, the runtime environment 10 is designed toscale; therefore, it can handle vast automated business systems withextremely high traffic to provide mission-critical processing services.It works in a distributed processing environment where additionalservers can be added to the central server network at any point andtransactions can be routed to available servers in real-time to balancethe load as data enters the system. If a server fails, the transactiontriggers notification to the other portions of the system, as well asthe system administrator, so that the transaction can roll back and thespecified server can be removed from the system.

In a preferred embodiment, multiple servers are placed in processingfarms, which are located within geographically distributed processingfacilities. Preferably, each processing facility is a Class 1 ComputerFacility with SAS 70 Certification.

5. Advantages Over Prior Art

The present invention allows for a radical decrease in the developmenttime of automated business systems, significantly reducing developmentcosts and time-to-market, which in turn increases return on investmentand overall efficiency for the companies who use automated businesssystems.

The present invention advances the current state of art in a number ofways. One of the key features of the invention is its ability to workwithin an existing development and runtime environment. The inventionhas also been designed to provide non-technical business users withunprecedented control over their automated business system builds.Business users are able to design, build, and deploy automated businesssystems without intervention by software engineers. Through the use ofthe invention, the creation of standard application pages can becompleted in one to two hours, rather than the 50 to 100 hours it takesin a typical software application development environment.

Because the invention is user-friendly, business user frustration isdrastically reduced in the page-building process. The amount of timerequired to test the system to ensure it functions properly has alsobeen streamlined through the implementation of the data modelingstandard. By employing this standard, the system eliminates the need fortesting specific design elements and designs. Additionally, theinvention allows for artifacts (such as page designs) to be saved andreused. The saved artifacts can then be used as templates for futureautomated business system builds.

The ability of the present invention to work generically across allindustries and with multiple database technologies is another importantdifferentiator from the systems available in today's market. Theinvention's handling and rendering of complex data in a user-friendlydesign environment is one of the most innovative capabilities of theinvention. The invention is capable of reading database structures froma wide variety of data structure technologies, allowing the invention toadapt to any environment and be used to build any type of automatedbusiness system without the need to employ software engineers. Once theinvention has read the data model, it automatically generates thedatabase interactions through the persistence layer, which is necessaryto store and retrieve data. The process that reads the data structureallows selective data from the overall structure to be viewed in auser-friendly format by business users from within the invention.

Another differentiator of the present invention is its ability to meetthe stringent security constraints required of automated businesssystems in the modern world. In addition to handling sensitive data, thesystem provides business users with the ability to set up and enforcepermissions and security so that each page and its associated artifactscan be restricted or allowed appropriately. Business users define therights and permissions for each end user depending on specific businessrequirements.

Lastly, the present invention has been designed to allow the addition ofprogrammer-created pages and frames into the overall automated businesssystem. These programmer-created pages and frames can be saved in thedesign repository in the same way that the tool-created pages and framesare saved. Programmer-created pages, frames and actions allow for evengreater technical functionality to be added to the automated businesssystem, thereby providing an easy way for non-technical business usersto implement complex functionality that could not otherwise be addedthrough the design environment.

Although the preferred embodiment of the present invention has beenshown and described, it will be apparent to those skilled in the artthat many changes and modifications may be made without departing fromthe invention in its broader aspects. The appended claims are thereforeintended to cover all such changes and modifications as fall within thetrue spirit and scope of the invention.

1. A system for rapid development of software applications comprising:(a) a field composer; (b) a design composer; and (c) a designrepository; wherein the field composer is used to create field trees;wherein the design composer is used to create designs; wherein a designis a partial or complete configuration of a software application;wherein one or more data models is/are derived from one or more existingdatabases; and wherein the design repository stores designs, fieldtrees, and data models.
 2. The system of claim 1, wherein a designcomprises programmer-created pages, programmer-created frames,tool-created pages, and/or tool-created frames.
 3. The system of claim1, further comprising a central server and a client, wherein the centralserver connects to the design repository and retrieves designs, fieldtrees and data model(s); wherein the client displays in a runtimeenvironment the software application that is created in the designcomposer; and wherein an end user enters, edits and/or reviews datathrough the client using the software application that is created in thedesign composer.
 4. The system of claim 3, wherein the central serveruses the data model(s) to connect to one or more customer databases;wherein the database from which each data model is derived has a schema;wherein each customer database has a schema; and wherein the schema ofthe database from which each data model is derived matches the schema ofat least one customer database.
 5. The system of claim 4, wherein thecustomer database is used by the software application to store andretrieve data entered by the end user through the client.
 6. The systemof claim 5, further comprising a persistence layer, wherein eachcustomer database has a native database query format; and wherein thepersistence layer translates the data entered by the end user to thenative database query format of the customer database.
 7. The system ofclaim 1, wherein more than one data model is used per softwareapplication created in the design composer.
 8. The system of claim 7,wherein the data models are derived from different types of databases.9. The system of claim 7, wherein there is a one-to-one relationshipbetween the number of data models used per software application createdin the design composer and the number of customer databases.
 10. Thesystem of claim 1, wherein a data modeling standard is used toautomatically infer the structure of the database schema of the databasefrom which the data model is to be derived.
 11. The system of claim 10,wherein after the data modeling standard is used to automatically inferthe structure of the database schema of the database from which the datamodel is to be derived, the data model is derived using a reverseengineering tool.
 12. The system of claim 1, wherein the field composercomprises a data model view and a field view; wherein each data modelcomprises fields; wherein the data model view is automatically populatedwith the fields from the data model(s); and wherein to create a fieldtree in the field composer, a business user drags and drops dataelements from the data model view to the field view of the fieldcomposer.
 13. The system of claim 12, wherein the design composercomprises a field tree window, and wherein the field tree created in thefield composer is displayed in the field tree window of the designcomposer.
 14. The system of claim 12, wherein a field tree may be builtfrom more than one data model, and wherein each data model isrepresented by a root in the field tree.
 15. The system of claim 13,wherein the field tree created in the field composer and displayed inthe field tree window of the design composer maps the data elements toone or more customer databases.
 16. The system of claim 1, furthercomprising a persistence layer, wherein the persistence layer is anapplication programming interface that communicates with an object modelpersistence application programming interface.
 17. The system of claim1, further comprising a persistence layer, wherein the persistence layeris an application programming interface that communicates directly withone or more data models.
 18. The system of claim 1, further comprising apersistence layer, wherein the persistence layer is used within thefield composer to create a hierarchical view of a relational data model.19. The system of claim 18, wherein the field composer comprises a datamodel view, and wherein the hierarchical view of the data model isdisplayed in the data model view of the field composer.
 20. The systemof claim 1, wherein each data model comprises fields, and wherein thefield composer allows business users to select data model(s) andspecific field from a data model for use on specific pages of thesoftware application.
 21. The system of claim 20, wherein the fieldcomposer comprises a data model view and a field view, wherein allavailable fields within a selected data model appear in the data modelview of the field composer, and wherein the selected fields appear inthe field view.
 22. The system of claim 20, wherein the selected fieldsare automatically saved and grouped according to the data model fromwhich they came.
 23. The system of claim 1, wherein a single field treeis created for each software application, and wherein the designcomposer is used to build the software application using the field treethat is created in the field composer.
 24. The system of claim 1,wherein the software application comprises one or more pages, whereineach page comprises a visual display, and wherein the design composer isused to configure the visual display of the pages in the softwareapplication.
 25. The system of claim 1, wherein the design composercomprises a properties window, a field tree window, a pages window, apalette window and a canvas.
 26. The system of claim 25, wherein thedesign composer further comprises a frames window.
 27. The system ofclaim 25, wherein the software application comprises one or more pages,and wherein the canvas is where business users design, build and modifythe pages of the software application.
 28. The system of claim 25,wherein the software application comprises one or more pages, whereinthe pages comprise design elements, and wherein the properties window isused to format the design elements of the pages.
 29. The system of claim25, wherein the software application has a page flow, and wherein thepage flow is defined in the properties window.
 30. The system of claim25, wherein the software application has a page flow, and wherein pageflow is controlled by events on buttons that have been dragged anddropped onto the canvas from the palette window.
 31. The system of claim25, wherein the software application comprises one or more pages, andwherein the field tree window is where a business user selects thefield(s) he wants to use on a page.
 32. The system of claim 25, whereinthe software application comprises one or more pages, and wherein thepages window is used to add, delete, modify and rename pages.
 33. Thesystem of claim 32, wherein the pages window allows a business user toadd programmer-created pages to the software application.
 34. The systemof claim 25, wherein the software application comprises one or morepages, and wherein the palette window is used to add design elements toa page.
 35. The system of claim 34, wherein the design elements that areadded from the palette window are arranged and sized on the canvas. 36.The system of claim 25, wherein a user selects a button from the palettewindow, drags and drops the button onto the canvas, and selects anaction from the properties window to apply to the button.
 37. The systemof claim 26, wherein the software application comprises one or morepages, and wherein the frames window is used to add one or more framesto a page.
 38. The system of claim 37, wherein each frame comprises oneor more design elements, and wherein when a design element in a frame ismodified, the modification propagates to every place in a design inwhich the frame is used.
 39. The system of claim 25, wherein thesoftware application comprises one or more pages, and wherein to build apage, a business user selects one or more fields from the field treewindow of the design composer and places them onto the canvas.
 40. Thesystem of claim 39, wherein the fields placed onto the canvas form alayout, and wherein the layout displayed on the canvas is identical tothat which will appear to an end user in a runtime environment.
 41. Thesystem of claim 1, wherein when a design is completed, the design issaved to the design repository.
 42. The system of claim 41, whereinmodified designs are saved as new versions, and wherein both new andprior versions are available for use in the design composer.
 43. Thesystem of claim 1, wherein when a design is completed and ready to berun in a runtime environment, the design is deployed from the designrepository to a central server.
 44. The system of claim 43, wherein thedesign repository is used to test the software application before it isdeployed to the runtime environment.
 45. The system of claim 1, whereindesigns, fields trees and data models that are stored in the designrepository are shared across multiple platforms and between end users.46. The system of claim 1, wherein the software application is run in aruntime environment, wherein the runtime environment provides for userpermissions, and wherein the user permissions include permissions foraccessing the application, permissions for accessing specific pages, andpermissions for accessing specific fields.
 47. A method for rapiddevelopment of software applications comprising: (d) providing a fieldcomposer; (e) providing a design composer; and (f) providing a designrepository; wherein the field composer is used to create field trees;wherein the design composer is used to create designs; wherein a designis a partial or complete configuration of a software application;wherein one or more data models is/are derived from one or more existingdatabases; and wherein the design repository stores designs, fieldtrees, and data models.
 48. The method of claim 47, wherein a designcomprises programmer-created pages, programmer-created frames,tool-created pages, and/or tool-created frames.
 49. The method of claim47, further comprising providing a central server and a client, whereinthe central server connects to the design repository and retrievesdesigns, field trees and data model(s); wherein the client displays in aruntime environment the software application that is created in thedesign composer; and wherein an end user enters, edits and/or reviewsdata through the client using the software application that is createdin the design composer.
 50. The method of claim 49, wherein the centralserver uses the data model(s) to connect to one or more customerdatabases; wherein the database from which each data model is derivedhas a schema; wherein each customer database has a schema; and whereinthe schema of the database from which each data model is derived matchesthe schema of at least one customer database.
 51. The method of claim50, wherein the customer database is used by the software application tostore and retrieve data entered by the end user through the client. 52.The method of claim 51, further comprising providing a persistencelayer, wherein each customer database has a native database queryformat; and wherein the persistence layer translates the data entered bythe end user to the native database query format of the customerdatabase.
 53. The method of claim 47, wherein more than one data modelis used per software application created in the design composer.
 54. Themethod of claim 53, wherein the data models are derived from differenttypes of databases.
 55. The method of claim 53, wherein there is aone-to-one relationship between the number of data models used persoftware application created in the design composer and the number ofcustomer databases.
 56. The method of claim 47, wherein a data modelingstandard is used to automatically infer the structure of the databaseschema of the database from which the data model is to be derived. 57.The method of claim 56, wherein after the data modeling standard is usedto automatically infer the structure of the database schema of thedatabase from which the data model is to be derived, the data model isderived using a reverse engineering tool.
 58. The method of claim 47,wherein the field composer comprises a data model view and a field view;wherein each data model comprises fields; wherein the data model view isautomatically populated with the fields from the data model(s); andwherein to create a field tree in the field composer, a business userdrags and drops data elements from the data model view to the field viewof the field composer.
 59. The method of claim 58, wherein the designcomposer comprises a field tree window, and wherein the field treecreated in the field composer is displayed in the field tree window ofthe design composer.
 60. The method of claim 58, wherein a field treemay be built from more than one data model, and wherein each data modelis represented by a root in the field tree.
 61. The method of claim 59,wherein the field tree created in the field composer and displayed inthe field tree window of the design composer maps the data elements toone or more customer databases.
 62. The method of claim 47, furthercomprising providing a persistence layer, wherein the persistence layeris an application programming interface that communicates with an objectmodel persistence application programming interface.
 63. The method ofclaim 47, further comprising providing a persistence layer, wherein thepersistence layer is an application programming interface thatcommunicates directly with one or more data models.
 64. The method ofclaim 47, further comprising providing a persistence layer, wherein thepersistence layer is used within the field composer to create ahierarchical view of a relational data model.
 65. The method of claim64, wherein the field composer comprises a data model view, and whereinthe hierarchical view of the data model is displayed in the data modelview of the field composer.
 66. The method of claim 47, wherein eachdata model comprises fields, and wherein the field composer allowsbusiness users to select data model(s) and specific field from a datamodel for use on specific pages of the software application.
 67. Themethod of claim 66, wherein the field composer comprises a data modelview and a field view, wherein all available fields within a selecteddata model appear in the data model view of the field composer, andwherein the selected fields appear in the field view.
 68. The method ofclaim 66, wherein the selected fields are automatically saved andgrouped according to the data model from which they came.
 69. The methodof claim 47, wherein a single field tree is created for each softwareapplication, and wherein the design composer is used to build thesoftware application using the field tree that is created in the fieldcomposer.
 70. The method of claim 47, wherein the software applicationcomprises one or more pages, wherein each page comprises a visualdisplay, and wherein the design composer is used to configure the visualdisplay of the pages in the software application.
 71. The method ofclaim 47, wherein the design composer comprises a properties window, afield tree window, a pages window, a palette window and a canvas. 72.The method of claim 71, wherein the design composer further comprises aframes window.
 73. The method of claim 71, wherein the softwareapplication comprises one or more pages, and wherein the canvas is wherebusiness users design, build and modify the pages of the softwareapplication.
 74. The method of claim 71, wherein the softwareapplication comprises one or more pages, wherein the pages comprisedesign elements, and wherein the properties window is used to format thedesign elements of the pages.
 75. The method of claim 71, wherein thesoftware application has a page flow, and wherein the page flow isdefined in the properties window.
 76. The method of claim 71, whereinthe software application has a page flow, and wherein page flow iscontrolled by events on buttons that have been dragged and dropped ontothe canvas from the palette window.
 77. The method of claim 71, whereinthe software application comprises one or more pages, and wherein thefield tree window is where a business user selects the field(s) he wantsto use on a page.
 78. The method of claim 71, wherein the softwareapplication comprises one or more pages, and wherein the pages window isused to add, delete, modify and rename pages.
 79. The method of claim78, wherein the pages window allows a business user to addprogrammer-created pages to the software application.
 80. The method ofclaim 71, wherein the software application comprises one or more pages,and wherein the palette window is used to add design elements to a page.81. The method of claim 80, wherein the design elements that are addedfrom the palette window are arranged and sized on the canvas.
 82. Themethod of claim 71, wherein a user selects a button from the palettewindow, drags and drops the button onto the canvas, and selects anaction from the properties window to apply to the button.
 83. The methodof claim 72, wherein the software application comprises one or morepages, and wherein the frames window is used to add one or more framesto a page.
 84. The method of claim 83, wherein each frame comprises oneor more design elements, and wherein when a design element in a frame ismodified, the modification propagates to every place in a design inwhich the frame is used.
 85. The method of claim 71, wherein thesoftware application comprises one or more pages, and wherein to build apage, a business user selects one or more fields from the field treewindow of the design composer and places them onto the canvas.
 86. Themethod of claim 85, wherein the fields placed onto the canvas form alayout, and wherein the layout displayed on the canvas is identical tothat which will appear to an end user in a runtime environment.
 87. Themethod of claim 47, wherein when a design is completed, the design issaved to the design repository.
 88. The method of claim 87, whereinmodified designs are saved as new versions, and wherein both new andprior versions are available for use in the design composer.
 89. Themethod of claim 47, wherein when a design is completed and ready to berun in a runtime environment, the design is deployed from the designrepository to a central server.
 90. The method of claim 89, wherein thedesign repository is used to test the software application before it isdeployed to the runtime environment.
 91. The method of claim 47, whereindesigns, fields trees and data models that are stored in the designrepository are shared across multiple platforms and between end users.92. The method of claim 47, wherein the software application is run in aruntime environment, wherein the runtime environment provides for userpermissions, and wherein the user permissions include permissions foraccessing the application, permissions for accessing specific pages, andpermissions for accessing specific fields.